3 线性神经网络

3.1 线性回归

回归（regression）是能为一个或多个自变量与因变量之间关系建模的一类方法。

3.1.1 随机梯度下降

梯度下降通过不断地在损失函数递减的方向上更新参数来降低误差。

\[ w \leftarrow w - \eta \frac{\partial(J)}{\partial(w)} \tag{3.1} \]

梯度下降最简单的用法是计算损失函数（数据集中所有样本的损失均值） 关于模型参数的导数（在这里也可以称为梯度）。 但实际中的执行可能会非常慢：因为在每一次更新参数之前，我们必须遍历整个数据集。 因此，我们通常会在每次需要计算更新的时候随机抽取一小批样本， 这种变体叫做小批量随机梯度下降。

在每次迭代中，我们首先随机抽样一个小批量\(B\)， 它是由固定数量的训练样本组成的。 然后，我们计算小批量的平均损失关于模型参数的导数（也可以称为梯度）。 最后，我们将梯度乘以一个预先确定的正数\(\eta\)，并从当前参数的值中减掉。

更具体的 \(B\)表示小批量中的样本数，也被称为批量大小（batch size） \(\eta\)称为学习率（learning rate），是一个正数，用来调节每次更新的幅度。 当\(\eta\)较小时，更新的幅度较小。 当\(\eta\)较大时，更新的幅度较大。 当\(\eta\)过大时，可能会使模型在优化过程中发散，甚至无法收敛到最优解。 当\(\eta\)过小时，模型优化的速度会过慢。

线性回归恰好是一个在整个域中只有一个最小值的学习问题。 但是对像深度神经网络这样复杂的模型来说，损失平面上通常包含多个最小值。 事实上，更难做到的是找到一组参数，这组参数能够在我们从未见过的数据上实现较低的损失， 这一挑战被称为泛化（generalization）。

3.1.2 矢量化加速

在训练我们的模型时，我们经常希望能够同时处理整个小批量的样本。 为了实现这一点，我们需要利用线性代数库，而不是在Python中编写开销较大的for循环。

例如 for i in range(n): c[i] = a[i] + b[i] 可以被替换为 c = a + b。

3.1.3 正态分布与平方损失

根据极大似然估计法，参数\(w\)和\(b\)的最优值是使整个数据集的似然最大的值。 由于平方损失函数，这等价于最小化平方损失。

3.1.4 从线性回归到深度网络

输入层的特征维度为\(d\)，输出层的输出维度为1，所表示的神经网络可以被认为是一个单层神经网络(通常我们计算层数时不考虑输入层)，如图3.1所示。

图3.1：线性回归是一个单层神经网络

3.2 线性回归的从零开始实现

# 3.2.1 生成数据集
import torch
import random

def synthetic_data(w, b, num_examples):
    """生成y=Xw+b+噪声"""
    X = torch.normal(0, 1, (num_examples, len(w))) # 生成一个1000行2列的矩阵
    y = torch.matmul(X, w) + b # y = Xw+b
    y += torch.normal(0, 0.01, y.shape) # 添加噪声，标准差为0.01的正态分布
    return X, y.reshape((-1, 1)) # y变为列向量

true_w = torch.tensor([2, -3.4])
true_b = 4.2
# 生成一个包含1000个样本的数据集， 每个样本包含从标准正态分布中采样的2个特征
features, labels = synthetic_data(true_w, true_b, 1000)

# 3.2.2 读取数据

# 训练模型时要对数据集进行遍历，每次抽取一小批量样本，并使用它们来更新我们的模型。
def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    
    random.shuffle(indices) # 打乱数据集中的样本并以小批量方式获取数据
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(indices[i: min(i + batch_size, num_examples)])
        # yield关键字来构造一个生成器，逐批返回数据和标签，用于高效地处理大数据集或在训练机器学习模型时进行小批量训练
        yield features[batch_indices], labels[batch_indices]

batch_size = 10
# 生成第一个小批量数据样本
for X, y in data_iter(batch_size, features, labels):
    print(X, '\n', y)
    break

# 3.2.3 初始化模型参数

# 使用随机数来初始化权重，偏置则初始化为0，同时启用张量的自动微分功能
w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True) 
b = torch.zeros(1, requires_grad=True)

# 3.2.4 定义模型

def linreg(X, w, b):
    """线性回归模型"""
    return torch.matmul(X, w) + b

# 3.2.5 定义损失函数

# 因为需要计算损失函数的梯度，所以我们应该先定义损失函数
def squared_loss(y_hat, y):
    """均方损失"""
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2 # 需要将真实值y的形状转换为和预测值y_hat的形状相同

# 3.2.6 定义优化算法(小批量随机梯度下降更新)

# 在每一步中，使用从数据集中随机抽取的一个小批量，然后根据参数计算损失的梯度。 接下来，朝着减少损失的方向更新我们的参数。
def sgd(params, lr, batch_size): # 模型参数，学习速率，批量大小
    """小批量随机梯度下降"""
    with torch.no_grad(): # 开启一个上下文，在该上下文中禁用梯度计算。参数更新和反向传播是不同的步骤
        for param in params:
            # 计算的损失是一个批量样本的总和，所以用批量大小（batch_size） 来规范化步长，这样步长大小就不会取决于我们对批量大小的选择。
            param -= lr * param.grad / batch_size # 每一步更新的大小由学习速率lr决定。 
            param.grad.zero_() # 梯度清零

# 3.2.7 训练

lr = 0.03 # 学习率
num_epochs = 3 # 训练轮次
net = linreg # 自定义模型
loss = squared_loss # 自定义损失函数

for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y)  # X和y的小批量损失
        # 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起，
        # 并以此计算关于[w,b]的梯度
        l.sum().backward() # 反向传播
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
    with torch.no_grad(): # 模型评估不需要反向传播
        train_l = loss(net(features, w, b), labels) # 打印当前模型在整个训练集上的损失
        print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')

# 3.2.8 对比真实值
print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

3.3 线性回归的简洁实现

使用深度学习框架的高级API简洁实现线性回归

# 3.3.1 生成数据集

from torch import nn
import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l

true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)

# 3.3.2 读取数据集

# 调用data函数，将features和labels作为参数传入，得到一个data.TensorDataset实例


def load_array(data_arrays, batch_size, is_train=True):
    # *data_arrays表示传入的是一个list，*表示解包
    dataset = data.TensorDataset(*data_arrays)
    # shuffle表示是否打乱数据
    return data.DataLoader(dataset, batch_size, shuffle=is_train)


batch_size = 10
data_iter = load_array((features, labels), batch_size)

# 读取并打印第一个小批量样本
next(iter(data_iter))  # 使用iter函数生成迭代器，使用next函数得到第一个元素

# 3.3.3 定义模型

# Sequential类将多个层串联在一起。 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入，以此类推。
# 全连接层在Linear类中定义。 该层的输出数量为1。
net = nn.Sequential(nn.Linear(2, 1))  # 直接指定输入和输出尺寸。2表示输入特征数，1表示输出特征数

# 3.3.4 初始化模型参数

# 通过net[0]访问Sequential实例中的第一层，然后使用weight.data和bias.data方法访问参数。
# 使用替换方法normal_和fill_来重写参数值
net[0].weight.data.normal_(0, 0.01)  # 均值为0，标准差为0.01的正态分布
net[0].bias.data.fill_(0)  # 使用fill_方法将偏置参数设置为0

# 3.3.5 定义损失函数

loss = nn.MSELoss()  # 均方误差损失函数

# 3.3.6 定义优化算法

# 指定优化的参数 （可通过net.parameters()从模型中获得）以及优化算法所需的超参数字典
trainer = torch.optim.SGD(net.parameters(), lr=0.03)  # 使用SGD优化算法，学习率为0.03

# 3.3.7 训练

num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        l = loss(net(X), y)
        trainer.zero_grad()
        l.backward()
        trainer.step()
    l = loss(net(features), labels)
    print(f'epoch {epoch + 1}, loss {l:f}')

# 比较学到的模型参数和真实l的模型参数
w = net[0].weight.data

print('w的估计误差:', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差:', true_b - b)

3.4 softmax回归

softmax运算获取一个向量并将其映射为概率，适用于分类问题，它使用了softmax运算中输出类别的概率分布。

3.4.1 分类问题

从一个图像分类问题开始。 假设每次输入是一个 2X2 的灰度图像。 我们可以用一个标量表示每个像素值，每个图像对应四个特征\(x_1,x_2,x_3,x_4\)。 此外，假设每个图像属于类别“猫”“鸡”和“狗”中的一个。(独热编码: 独热编码是一个向量，它的分量和类别一样多。 类别对应的分量设置为1，其他所有分量设置为0。)

3.4.2 网络架构

为了估计所有可能类别的条件概率，我们需要一个有多个输出的模型，每个类别对应一个输出。 为了解决线性模型的分类问题，我们需要和输出一样多的仿射函数（affine function）。

\[ \begin{gathered} o_1 &= x_1 w_{11} + x_2 w_{12} + x_3 w_{13} + x_4 w_{14} + b_1,\\ o_2 &= x_1 w_{21} + x_2 w_{22} + x_3 w_{23} + x_4 w_{24} + b_2,\\ o_3 &= x_1 w_{31} + x_2 w_{32} + x_3 w_{33} + x_4 w_{34} + b_3. \end{gathered} \tag{3.2} \]

表达为向量形式\(\mathbf{o} = \mathbf{W} \mathbf{x} + \mathbf{b}\)

因此可以构建如下的单层神经网络(同样的，也是全连接层)：

图3.2：softmax回归是一个单层神经网络

3.4.3 全连接层的参数开销

全连接层是“完全”连接的，可能有很多可学习的参数。 具体来说，对于任何具有d个输入和p个输出的全连接层， 参数开销为\(\mathcal{O}(dq)\)，这个数字在实践中可能高得令人望而却步。 幸运的是，将d个输入转换为q个输出的成本可以减少到\(\mathcal{O}(\frac{dq}{n})\)。其中，其中超参数n可以由我们灵活指定

3.4.4. softmax运算

现在我们将优化参数以最大化观测数据的概率。 为了得到预测结果，我们将设置一个阈值，如选择具有最大概率的标签。

然而我们能否将未规范化的预测\(o\)直接视作我们感兴趣的输出呢？ 答案是否定的。 因为将线性层的输出直接视为概率时存在一些问题： 一方面，我们没有限制这些输出数字的总和为1。 另一方面，根据输入的不同，它们可以为负值。要将输出视为概率，我们必须保证在任何数据上的输出都是非负的且总和为1。

由此引出softmax函数:

\[ \hat{\mathbf{y}} = \mathrm{softmax}(\mathbf{o})\quad \text{其中}\quad \hat{y}_j = \frac{\exp(o_j)}{\sum_k \exp(o_k)} \tag{3.3} \]

\(\hat{\mathbf{y}}\)可以视为一个正确的概率分布。 softmax运算不会改变未规范化的预测\(o\)之间的大小次序，从而依旧是:

\[ \operatorname*{argmax}_j \hat y_j = \operatorname*{argmax}_j o_j. \tag{3.4} \]

尽管softmax是一个非线性函数，但softmax回归的输出仍然由输入特征的仿射变换决定。 因此，softmax回归是一个线性模型（linear model）。

3.4.5. 小批量样本的矢量化

为了提高计算效率并且充分利用GPU，我们通常会对小批量样本的数据执行矢量计算。假设我们读取了一个批量的样本\(X\)， 其中特征维度（输入数量）为\(d\)，批量大小为\(n\)。 此外，假设我们在输出中有\(q\)个类别。 那么小批量样本的特征为\(\mathbf{X} \in \mathbb{R}^{n \times d}\)， 权重为\(\mathbf{W} \in \mathbb{R}^{d \times q}\)， 偏置为\(\mathbf{b} \in \mathbb{R}^{1\times q}\)。 softmax回归的矢量计算表达式为：

\[ \begin{gathered} \mathbf{O} &= \mathbf{X} \mathbf{W} + \mathbf{b}, \\ \hat{\mathbf{Y}} & = \mathrm{softmax}(\mathbf{O}). \end{gathered} \tag{3.5} \]

相对于一次处理一个样本， 小批量样本的矢量化加快了\(X\)和\(W\)的矩阵-向量乘法。

3.4.6 损失函数

同线性回归一样，使用最大似然估计法。

交叉熵损失(是分类问题最常用的损失之一，是一个衡量两个概率分布之间差异的很好的度量，它测量给定模型编码数据所需的比特数):

\[ l(\mathbf{y}, \hat{\mathbf{y}}) = - \sum_{j=1}^q y_j \log \hat{y}_j. \tag{3.6} \]

3.5 图像分类数据集

MNIST数据集是图像分类中广泛使用的数据集之一，但作为基准数据集过于简单。 我们将使用类似但更复杂的Fashion-MNIST数据集。

import torch
import torchvision
from torch.utils import data
from torchvision import transforms
from d2l import torch as d2l

d2l.use_svg_display()

# 3.5.1 读取数据集

# 3.5.1.1 通过框架中的内置函数将Fashion-MNIST数据集下载并读取到内存中
trans = transforms.ToTensor() # 通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式，并除以255使得所有像素的数值均在0～1之间
mnist_train = torchvision.datasets.FashionMNIST(
    root="../data", train=True, transform=trans, download=True)
mnist_test = torchvision.datasets.FashionMNIST(
    root="../data", train=False, transform=trans, download=True)

# Fashion-MNIST由10个类别的图像组成， 每个类别由训练数据集（train dataset）中的6000张图像 和测试数据集（test dataset）中的1000张图像组成。 
# 因此，训练集和测试集分别包含60000和10000张图像。 测试数据集不会用于训练，只用于评估模型性能。
print(len(mnist_train), len(mnist_test))
# 每个输入图像的高度和宽度均为28像素。 数据集由灰度图像组成，其通道数为1
print(mnist_train[0][0].shape) # torch.Size([1, 28, 28])

# 3.5.1.2 在数字标签索引及其文本名称之间进行转换
def get_fashion_mnist_labels(labels):
    """返回Fashion-MNIST数据集的文本标签"""
    text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
                   'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
    return [text_labels[int(i)] for i in labels]

# 3.5.1.3 可视化样本
def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5):
    """绘制图像列表"""
    figsize = (num_cols * scale, num_rows * scale)
    _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
    axes = axes.flatten()
    for i, (ax, img) in enumerate(zip(axes, imgs)):
        if torch.is_tensor(img):
            # 图片张量
            ax.imshow(img.numpy())
        else:
            # PIL图片
            ax.imshow(img)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        if titles:
            ax.set_title(titles[i])
    return axes

# 展示前几个样本
X, y = next(iter(data.DataLoader(mnist_train, batch_size=18)))
show_images(X.reshape(18, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y));

# 3.5.2 小批量读取

# 使用内置的数据迭代器，每次都会读取一小批量数据，大小为batch_size。同时随机打乱所有样本，从而无偏见地读取小批量
batch_size = 256

def get_dataloader_workers():
    """使用4个进程来读取数据"""
    return 4


# 3.5.3 整合所有组件

# 获取和读取Fashion-MNIST数据集，返回训练集和验证集的数据迭代器。
def load_data_fashion_mnist(batch_size, resize=None):
    """下载Fashion-MNIST数据集，然后将其加载到内存中"""
    trans = [transforms.ToTensor()]
    if resize: # 可选参数resize，用来将图像大小调整为另一种形状
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(
        root="../data", train=True, transform=trans, download=True)
    mnist_test = torchvision.datasets.FashionMNIST(
        root="../data", train=False, transform=trans, download=True)
    return (data.DataLoader(mnist_train, batch_size, shuffle=True, num_workers=get_dataloader_workers()),
            data.DataLoader(mnist_test, batch_size, shuffle=False, num_workers=get_dataloader_workers()))

# 得到训练集和测试集的数据迭代器(测试load_data_fashion_mnist函数的图像大小调整功能)
train_iter, test_iter = load_data_fashion_mnist(32, resize=64)
for X, y in train_iter:
    # torch.Size([32, 1, 64, 64])   torch.float32   torch.Size([32])    torch.int64 
    print(X.shape, X.dtype, y.shape, y.dtype)
    break

3.6 softmax回归的从零开始实现

既然我们已经引入了Fashion-MNIST数据集，让我们使用softmax回归从零开始实现它。

import torch
from IPython import display
from d2l import torch as d2l

# 3.6.1 初始化模型参数(放入main函数中)

# 原始输入图像大小是28*28，这里将其转换为长度为28*28=784的向量
# 由于有10个类别，所以输出层的输出个数为10
# 因此，权重将构成一个784*10的矩阵
# 偏置将构成一个10维的向量

# 3.6.2 实现softmax运算

def softmax(X):
    # 1. 对每个项求幂（使用exp）；
    X_exp = torch.exp(X)
    # 2. 对每一行求和（小批量中每个样本是一行），得到每个样本的规范化常数；
    partition = X_exp.sum(1, keepdim=True) # 调用sum时，可以指定保持在原始张量的轴数，而不折叠求和的维度。其中1表示沿行求和，keepdim=True保持列向量的形状
    # 3. 将每一行除以其规范化常数，确保结果的和为1。
    return X_exp / partition  # 这里应用了广播机制

# 3.6.3 定义模型

# 输入通过网络映射到输出
def net(X):
    # 通过reshape函数将每张原始图像改为长度为num_inputs的向量，即reshape((-1, 784))。
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

# 3.6.4 定义损失函数

# 交叉熵损失函数
def cross_entropy(y_hat, y): # y_hat是预测概率，y是标签
    return -torch.log(y_hat[range(len(y_hat)), y])

# 3.6.5 计算分类准确率

# 计算准确率
def accuracy(y_hat, y):
    """计算预测正确的数量"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)  # 返回沿轴axis最大值的索引
    cmp = y_hat.type(y.dtype) == y # 匹配数据类型并比较，返回布尔值0或1
    return float(cmp.type(y.dtype).sum())

# 评估模型net的精度
def evaluate_accuracy(net, data_iter):
    """计算在指定数据集上模型的精度"""
    if isinstance(net, torch.nn.Module): # 如果是torch.nn.Module实例，使用isinstance函数返回True
        net.eval()  # 将模型设置为评估模式
    metric = Accumulator(2)  # 正确预测数、预测总数(自定义的累加器类)
    with torch.no_grad(): # 不计算梯度
        for X, y in data_iter:
            metric.add(accuracy(net(X), y), y.numel()) # 累加每个batch_size个样本的准确率和样本数
    return metric[0] / metric[1]

# 3.6.6 训练模型

# 定义一个函数来训练一个迭代周期
def train_epoch_ch3(net, train_iter, loss, updater):
    """训练模型一个迭代周期"""
    # 将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()
    # 训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)
    for X, y in train_iter:
        # 计算梯度并更新参数
        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad()
            l.mean().backward()
            updater.step()
        else:
            # 使用定制的优化器和损失函数
            l.sum().backward()
            updater(X.shape[0])
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    # 返回训练损失和训练精度
    return metric[0] / metric[2], metric[1] / metric[2]

# 训练函数
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    """训练模型"""
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    for epoch in range(num_epochs):
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        test_acc = evaluate_accuracy(net, test_iter)
        animator.add(epoch + 1, train_metrics + (test_acc,))
    train_loss, train_acc = train_metrics
    assert train_loss < 0.5, train_loss
    assert train_acc <= 1 and train_acc > 0.7, train_acc
    assert test_acc <= 1 and test_acc > 0.7, test_acc

# 小批量随机梯度下降来优化模型的损失函数
def updater(batch_size):
    return d2l.sgd([W, b], lr, batch_size)

# 3.6.7 预测

def predict_ch3(net, test_iter, n=6):
    """预测标签"""
    for X, y in test_iter: # 取一个batch_size的数据
        break
    trues = d2l.get_fashion_mnist_labels(y) # 真实标签
    preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1)) # 预测标签
    titles = [true +'\n' + pred for true, pred in zip(trues, preds)] # 标题
    d2l.show_images(X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n]) # 显示图片

# Helper class

# 累加器类
class Accumulator:  #@save
    """在n个变量上累加"""
    def __init__(self, n):
        self.data = [0.0] * n

    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]

    def reset(self):
        self.data = [0.0] * len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]

# 数据可视化
class Animator:
    """在动画中绘制数据"""
    def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None,
                 ylim=None, xscale='linear', yscale='linear',
                 fmts=('-', 'm--', 'g-.', 'r:'), nrows=1, ncols=1,
                 figsize=(3.5, 2.5)):
        # 增量地绘制多条线
        if legend is None:
            legend = []
        d2l.use_svg_display()
        self.fig, self.axes = d2l.plt.subplots(nrows, ncols, figsize=figsize)
        if nrows * ncols == 1:
            self.axes = [self.axes, ]
        # 使用lambda函数捕获参数
        self.config_axes = lambda: d2l.set_axes(
            self.axes[0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
        self.X, self.Y, self.fmts = None, None, fmts

    def add(self, x, y):
        # 向图表中添加多个数据点
        if not hasattr(y, "__len__"):
            y = [y]
        n = len(y)
        if not hasattr(x, "__len__"):
            x = [x] * n
        if not self.X:
            self.X = [[] for _ in range(n)]
        if not self.Y:
            self.Y = [[] for _ in range(n)]
        for i, (a, b) in enumerate(zip(x, y)):
            if a is not None and b is not None:
                self.X[i].append(a)
                self.Y[i].append(b)
        self.axes[0].cla()
        for x, y, fmt in zip(self.X, self.Y, self.fmts):
            self.axes[0].plot(x, y, fmt)
        self.config_axes()
        display.display(self.fig)
        display.clear_output(wait=True)

if __name__ == '__main__':
    # 读取数据
    batch_size = 256
    train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size) # 加载数据集

    # 初始化模型参数
    # 原始输入图像大小是28*28，这里将其转换为长度为28*28=784的向量
    num_inputs = 784
    # 由于有10个类别，所以输出层的输出个数为10
    num_outputs = 10
    # 因此，权重将构成一个784*10的矩阵
    W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
    # 偏置将构成一个10维的向量
    b = torch.zeros(num_outputs, requires_grad=True)

    # 训练模型
    lr = 0.1
    num_epochs = 10
    updater = lambda batch_size: d2l.sgd([W, b], lr, batch_size)
    train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)
    # 预测
    predict_ch3(net, test_iter)

3.7 softmax回归的简洁实现

import torch
from torch import nn
from d2l import torch as d2l

# 3.7.1 获取和读取数据


# 3.7.2 初始化模型参数

# softmax回归的输出层是一个全连接层。 因此只需在Sequential中添加一个带有10个输出的全连接层
def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

# 3.7.3 重新审视Softmax的实现
# 在交叉熵损失函数中传递未规范化的预测，并同时计算softmax及其对数
# PyTorch中的CrossEntropyLoss类将softmax运算和交叉熵损失计算结合在一起，同时避免了数值不稳定性

# 3.7.4 优化算法
# 与线性回归中的相同，softmax回归也使用小批量随机梯度下降作为优化算法。

# 3.7.5 训练
# 通过调用优化算法的step函数来迭代模型参数

if __name__ == '__main__':
    # 3.7.1 获取和读取数据
    batch_size = 256
    train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

    # 3.7.2 初始化模型参数
    # PyTorch不会隐式地调整输入的形状。因此，我们在线性层前定义了展平层（flatten），来调整网络输入的形状
    net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))
    net.apply(init_weights);

    # 3.7.3 重新审视Softmax的实现
    loss = nn.CrossEntropyLoss(reduction='none')

    # 3.7.4 优化算法
    trainer = torch.optim.SGD(net.parameters(), lr=0.1)

    # 3.7.5 训练(3.6.6节中定义的训练函数)
    num_epochs = 10
    d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)